/**
 * 智能体模式执行器 - 集成现有的UT生成逻辑
 */
import * as vscode from 'vscode';
import * as path from 'path';
import { UTBuildGNUpdater } from '../services/UTBuildGNUpdater';
import * as fs from 'fs';
import { LLMFactory } from '../../../../core/llm/llmFactory';
import { Logger } from '../../../../src/logger/Logger';
import { TreeSitter } from '../../../../core/treesitter/TreeSitter';
import { CxxLanguageServer } from '../services/CxxLanguageServer';
import { GNFileManager } from '../GNFileManager';
import { LLMAnalyzer } from './LLMAnalyzer';
import { CoverageAnalyzer } from '../CoverageAnalyzer';
import { ProjectAnalyzer } from '../ProjectAnalyzer';
import { 
    CodeAnalysisResult, 
    DependencyAnalysisResult,
    GNAnalysisResult,
    StreamMessage 
} from './MessageProtocol';
import { ProjectStructureAnalyzer, ProjectStructure } from './ProjectStructureAnalyzer';
import { PromptEnhancerSelector } from '../PromptEnhancerSelector';
// import { UltraDeepPromptEnhancer } from '../UltraDeepPromptEnhancer'; // 保留作为备份
// import { FunctionMappingPromptEnhancer } from '../FunctionMappingPromptEnhancer'; // 已合并到UltraDeepPromptEnhancer
import { ChatMessage } from '../../../../core/index';

export class AgentModeExecutor {
    private currentTestCode: string = '';
    private llmAnalyzer: LLMAnalyzer;
    private useLLMAnalysis: boolean = true;  // 默认使用 LLM 分析
    private conversationHistory: ChatMessage[] = [];  // 新增：对话历史，用于后续优化
    private currentDocument: vscode.TextDocument | undefined;  // 新增：保存文档上下文
    private currentPosition: vscode.Position | undefined;  // 新增：保存位置上下文
    private lastGeneratedCode: string = '';  // 新增：保存最后生成的代码用于对比
    private currentAbortController: AbortController | null = null;  // 新增：取消控制器
    private isPaused: boolean = false;  // 新增：暂停标志
    private pausePromiseResolver: (() => void) | null = null;  // 新增：用于恢复的Promise

    constructor(
        private llmFactory: LLMFactory,
        private sendMessage: (msg: StreamMessage) => void
    ) {
        this.llmAnalyzer = new LLMAnalyzer(llmFactory);
        
        // 从配置读取是否使用 LLM 分析
        const config = vscode.workspace.getConfiguration('harmonypilot');
        this.useLLMAnalysis = config.get<boolean>('unitTest.useLLMAnalysis', true);
        
        Logger.info(`[Agent Mode] LLM 分析模式: ${this.useLLMAnalysis ? '启用' : '禁用'}`);
    }

    /**
     * 分析源代码
     */
    async analyzeCode(
        document: vscode.TextDocument,
        position: vscode.Position,
        selectedText?: string  // 新增：选中的代码文本
    ): Promise<CodeAnalysisResult> {
        Logger.info(`[analyzeCode] 开始分析代码`);
        Logger.info(`[analyzeCode] Document URI: ${document.uri.toString()}`);
        Logger.info(`[analyzeCode] Document languageId: ${document.languageId}`);
        Logger.info(`[analyzeCode] Document lineCount: ${document.lineCount}`);
        Logger.info(`[analyzeCode] Position: line ${position.line}, character ${position.character}`);
        Logger.info(`[analyzeCode] Selected text length: ${selectedText ? selectedText.length : 0}`);
        
        this.sendProgress(1, 10, '初始化 TreeSitter 解析器...');
        
        // 初始化 TreeSitter
        await TreeSitter.getInstance().init();
        
        this.sendProgress(1, 30, '解析函数签名...');
        
        // 获取当前函数的详细信息
        const functionTypes = await TreeSitter.getInstance().getFunctionTypes(document, true);
        Logger.info(`[analyzeCode] getFunctionTypes 返回: ${functionTypes ? functionTypes.length : 'null/undefined'} 个函数`);
        
        if (!functionTypes || functionTypes.length === 0) {
            Logger.error(`[analyzeCode] 未找到函数定义。Document languageId: ${document.languageId}`);
            Logger.error(`[analyzeCode] 这可能是因为：1) 文件中没有函数定义 2) TreeSitter 解析器未正确初始化 3) C++ 代码语法有问题`);
            throw new Error('未找到函数定义。请确保光标在一个有效的 C/C++ 函数内。');
        }

        // 如果有选中文本，找出选中范围内的所有函数
        let targetFunctions: any[] = [];
        
        if (selectedText) {
            Logger.info(`[analyzeCode] 📝 检测到选中文本，长度: ${selectedText.length} 字符`);
            const editor = vscode.window.activeTextEditor;
            if (editor && !editor.selection.isEmpty) {
                const selectionStart = editor.selection.start.line;
                const selectionEnd = editor.selection.end.line;
                
                Logger.info(`[analyzeCode] 📍 选中范围: [行 ${selectionStart} 到行 ${selectionEnd}]`);
                Logger.info(`[analyzeCode] 🔍 开始在选中范围内查找函数...`);
                
                // 找到选中范围内的所有函数
                for (const func of functionTypes) {
                    Logger.info(`[analyzeCode]   检查函数 "${func.name}": 范围 [${func.range.start.line}, ${func.range.end.line}]`);
                    // 检查函数是否在选中范围内（函数的任何部分与选中范围有交集）
                    if (func.range.start.line <= selectionEnd && func.range.end.line >= selectionStart) {
                        targetFunctions.push(func);
                        Logger.info(`[analyzeCode]   ✅ 函数 "${func.name}" 在选中范围内`);
                    }
                }
                
                Logger.info(`[analyzeCode] ✅ 在选中范围内找到 ${targetFunctions.length} 个函数`);
            } else {
                Logger.warn(`[analyzeCode] ⚠️ 有选中文本但编辑器选区为空`);
            }
        } else {
            // 🆕 策略改进：没有选中文本时，生成所有公共函数的测试（而不仅仅是光标所在函数）
            Logger.info(`[analyzeCode] 📝 没有选中文本，将为所有公共函数生成测试`);
            Logger.info(`[analyzeCode] 📊 文件中共有 ${functionTypes.length} 个函数`);
            
            // 过滤：排除析构函数和明显不需要测试的函数
            targetFunctions = functionTypes.filter(func => {
                const funcName = func.name.toLowerCase();
                
                // 排除规则：
                // 1. 析构函数（~）- 通常由编译器自动调用，无需测试
                // 2. 构造函数可以测试（通过实例化验证）
                // 3. 私有函数保留（可通过 GN 中 private = public 暴露，或通过 public 方法间接覆盖）
                // 4. static/helper/internal 函数保留（都是需要测试的）
                if (funcName.startsWith('~')) {
                    Logger.info(`[analyzeCode]   ✖️ 跳过析构函数: ${func.name}`);
                    return false;
                }
                
                Logger.info(`[analyzeCode]   ✅ 包含函数: ${func.name}`);
                return true;
            });
            
            Logger.info(`[analyzeCode] 🎯 过滤后保留 ${targetFunctions.length} 个公共函数`);
            
            // 如果过滤后没有函数，尝试使用光标所在的函数作为后备
            if (targetFunctions.length === 0) {
                Logger.warn(`[analyzeCode] ⚠️ 过滤后没有公共函数，回退到光标所在函数`);
                
                let targetFunction: any = null;
                for (const func of functionTypes) {
                    if (func.range.contains(position)) {
                        targetFunction = func;
                        Logger.info(`[analyzeCode] 找到光标所在函数: ${func.name}`);
                        break;
                    }
                }

                // 如果未找到光标所在的函数，使用最近的函数
                if (!targetFunction && functionTypes.length > 0) {
                    Logger.warn(`[analyzeCode] 未找到光标所在函数，使用最近的函数`);
                    
                    let minDistance = Infinity;
                    for (const func of functionTypes) {
                        const distance = Math.abs(func.range.start.line - position.line);
                        if (distance < minDistance) {
                            minDistance = distance;
                            targetFunction = func;
                        }
                    }
                    
                    if (targetFunction) {
                        Logger.info(`[analyzeCode] 使用最近的函数: ${targetFunction.name}`);
                    }
                }
                
                if (targetFunction) {
                    targetFunctions = [targetFunction];
                } else {
                    Logger.error(`[analyzeCode] 无法找到任何函数。光标位置: ${position.line}:${position.character}`);
                    throw new Error('未找到可分析的函数。请将光标放在函数定义内，或选择要测试的函数。');
                }
            }
        }
        
        // 如果没有找到任何函数，抛出错误
        if (targetFunctions.length === 0) {
            Logger.error(`[analyzeCode] ❌ 未找到可测试的函数`);
            throw new Error('未找到可分析的函数。请将光标放在函数定义内，或选择要测试的函数。');
        }
        
        // 如果找到多个函数，记录并返回第一个（后续可以扩展为支持多函数测试）
        if (targetFunctions.length > 1) {
            const functionNames = targetFunctions.map(f => f.name).join(', ');
            Logger.info(`[analyzeCode] 🎯 找到 ${targetFunctions.length} 个函数: ${functionNames}`);
            Logger.info(`[analyzeCode] 📋 将为以下函数生成测试:`);
            targetFunctions.forEach((f, idx) => {
                Logger.info(`[analyzeCode]   ${idx + 1}. ${f.name} (行 ${f.range.start.line}-${f.range.end.line})`);
            });
            
            this.sendMessage({
                type: 'info',
                level: 'info',
                message: `📝 检测到 ${targetFunctions.length} 个函数: ${functionNames}\n将为所有函数生成测试代码...`
            });
        } else if (targetFunctions.length === 1) {
            Logger.info(`[analyzeCode] 🎯 找到 1 个函数: ${targetFunctions[0].name}`);
        }
        
        // 使用第一个函数进行分析（TODO: 后续可以支持多函数合并分析）
        const targetFunction = targetFunctions[0];

        this.sendProgress(1, 60, '分析函数参数...');

        // 使用 Language Server 获取更详细的信息
        const symbols = await CxxLanguageServer.getInstance().getDocumentSymbol(document);
        let functionSymbol: any = null;
        
        if (symbols) {
            for (const symbol of symbols) {
                if (symbol.name === targetFunction.name || 
                    symbol.detail?.includes(targetFunction.name)) {
                    functionSymbol = symbol;
                    break;
                }
            }
        }

        this.sendProgress(1, 90, '完成代码分析');

        // 分析复杂度
        const complexity = this.analyzeComplexity(targetFunction);
        
        // 🆕 尝试查找并分析对应的头文件
        let headerInfo: any = null;
        try {
            const sourceFilePath = document.uri.fsPath;
            const headerFilePath = this.findCorrespondingHeader(sourceFilePath);
            
            if (headerFilePath && fs.existsSync(headerFilePath)) {
                Logger.info(`[analyzeCode] 📄 找到对应的头文件: ${headerFilePath}`);
                this.sendProgress(1, 95, '分析头文件...');
                headerInfo = await this.analyzeHeaderFile(headerFilePath);
                
                if (headerInfo) {
                    Logger.info(`[analyzeCode] ✅ 头文件分析完成:`);
                    Logger.info(`[analyzeCode]    类名: ${headerInfo.className || '未知'}`);
                    Logger.info(`[analyzeCode]    成员变量: ${headerInfo.memberVariables?.length || 0} 个`);
                    Logger.info(`[analyzeCode]    成员函数: ${headerInfo.memberFunctions?.length || 0} 个`);
                    Logger.info(`[analyzeCode]    头文件依赖: ${headerInfo.includes?.length || 0} 个`);
                }
            } else {
                Logger.info(`[analyzeCode] ℹ️ 未找到对应的头文件`);
            }
        } catch (error) {
            Logger.warn(`[analyzeCode] ⚠️ 头文件分析失败: ${error}`);
        }

        return {
            functionName: targetFunction.name,
            className: headerInfo?.className || '', // 从头文件中提取类名
            parameters: functionSymbol?.children?.map((child: any) => ({
                name: child.name,
                type: child.detail || 'unknown'
            })) || [],
            returnType: functionSymbol?.detail?.match(/:\s*(\w+)/)?.[1] || 'void',
            isStatic: false, // TODO: 检测是否静态
            isTemplate: false, // TODO: 检测模板
            complexity,
            headerInfo  // 🆕 添加头文件信息
        };
    }
    
    /**
     * 查找 cpp 文件对应的头文件
     */
    private findCorrespondingHeader(cppFilePath: string): string | null {
        const baseName = path.basename(cppFilePath, path.extname(cppFilePath));
        const dir = path.dirname(cppFilePath);
        
        // 尝试不同的可能路径
        const possiblePaths = [
            // 同目录下
            path.join(dir, `${baseName}.h`),
            path.join(dir, `${baseName}.hpp`),
            // include 目录（上一级）
            path.join(dir, '..', 'include', `${baseName}.h`),
            path.join(dir, '..', 'include', `${baseName}.hpp`),
            // inc 目录
            path.join(dir, '..', 'inc', `${baseName}.h`),
            // 同级 include 目录
            path.join(dir, 'include', `${baseName}.h`),
        ];
        
        for (const headerPath of possiblePaths) {
            if (fs.existsSync(headerPath)) {
                return headerPath;
            }
        }
        
        return null;
    }
    
    /**
     * 分析头文件内容
     */
    private async analyzeHeaderFile(headerFilePath: string): Promise<any> {
        try {
            const content = fs.readFileSync(headerFilePath, 'utf8');
            
            // 提取类名
            const classMatch = content.match(/class\s+([A-Z][a-zA-Z0-9_]*)/);
            const className = classMatch ? classMatch[1] : null;
            
            // 提取 #include
            const includeRegex = /#include\s*[<"]([^>"]+)[>"]/g;
            const includes: string[] = [];
            let match;
            while ((match = includeRegex.exec(content)) !== null) {
                includes.push(match[1]);
            }
            
            // 提取成员变量（简单正则）
            const memberVarRegex = /^\s*(private|protected|public):\s*$[\s\S]*?(?:^\s*\w+[\w\s\*&:<>,]*\s+(\w+_);)/gm;
            const memberVariables: Array<{name: string, access: string}> = [];
            
            // 更简单的方法：查找所有以下划线结尾的变量声明（OpenHarmony命名约定）
            const varRegex = /(\w+[\w\s\*&:<>,]*)\s+(\w+_);/g;
            while ((match = varRegex.exec(content)) !== null) {
                memberVariables.push({
                    name: match[2],
                    access: 'private'  // 大多数成员变量是private
                });
            }
            
            // 提取成员函数声明
            const funcRegex = /^\s*(virtual\s+)?(\w+[\w\s\*&:<>,]*)\s+(\w+)\s*\([^)]*\)/gm;
            const memberFunctions: string[] = [];
            while ((match = funcRegex.exec(content)) !== null) {
                memberFunctions.push(match[3]);  // 函数名
            }
            
            return {
                className,
                includes,
                memberVariables,
                memberFunctions,
                fullContent: content  // 保存完整内容供后续使用
            };
        } catch (error) {
            Logger.error(`[analyzeHeaderFile] 分析失败: ${error}`);
            return null;
        }
    }

    /**
     * 分析依赖关系（智能模式：优先使用 LLM，降级到传统解析）
     */
    async analyzeDependencies(
        document: vscode.TextDocument
    ): Promise<DependencyAnalysisResult> {
        const text = document.getText();
        const fileName = path.basename(document.uri.fsPath);
        
        // 尝试使用 LLM 分析
        if (this.useLLMAnalysis) {
            try {
                this.sendProgress(2, 20, '使用 AI 智能分析依赖关系...');
                
                const llmResult = await this.llmAnalyzer.analyzeDependenciesWithLLM(text, fileName);
                
                // 检查是否成功
                if (llmResult.includes.length > 0 || llmResult.externalDependencies.length > 0) {
                    this.sendProgress(2, 100, 'AI 依赖分析完成');
                    Logger.info(`[Agent Mode] LLM 依赖分析成功: ${llmResult.externalDependencies.length} 个依赖`);
                    return llmResult;
                }
                
                Logger.warn('[Agent Mode] LLM 依赖分析返回空结果，降级到传统解析');
            } catch (error) {
                Logger.error(`[Agent Mode] LLM 依赖分析失败: ${error}，降级到传统解析`);
                this.sendProgress(2, 30, 'AI 分析失败，使用传统方法...');
            }
        }
        
        // 降级到传统解析方法
        return this.analyzeDependenciesTraditional(document);
    }
    
    /**
     * 传统的依赖分析方法（作为后备方案）
     */
    private async analyzeDependenciesTraditional(
        document: vscode.TextDocument
    ): Promise<DependencyAnalysisResult> {
        this.sendProgress(2, 20, '扫描 #include 语句...');

        const text = document.getText();
        const includeRegex = /#include\s*[<"]([^>"]+)[>"]/g;
        const includes: string[] = [];
        let match;

        while ((match = includeRegex.exec(text)) !== null) {
            includes.push(match[1]);
        }

        this.sendProgress(2, 50, '分析外部依赖...');

        // 简单分析：查找类和函数调用
        const externalDependencies: Array<{
            name: string;
            type: 'class' | 'function' | 'library';
            mockable: boolean;
            reason?: string;
        }> = [];

        // 查找类的使用
        const classUsageRegex = /\b([A-Z][a-zA-Z0-9_]*)::/g;
        const classNames = new Set<string>();
        while ((match = classUsageRegex.exec(text)) !== null) {
            classNames.add(match[1]);
        }

        for (const className of classNames) {
            externalDependencies.push({
                name: className,
                type: 'class',
                mockable: true,
                reason: '通过正则表达式匹配发现'
            });
        }

        this.sendProgress(2, 100, '依赖分析完成（传统方法）');

        const suggestions: string[] = [];
        if (externalDependencies.length > 0) {
            suggestions.push(`发现 ${externalDependencies.length} 个外部依赖，建议使用 Mock 对象`);
        }
        if (includes.some(inc => inc.includes('thread') || inc.includes('async'))) {
            suggestions.push('检测到多线程或异步代码，建议添加同步测试');
        }

        Logger.info(`[Agent Mode] 传统依赖分析完成: ${externalDependencies.length} 个依赖`);

        return {
            includes,
            externalDependencies,
            suggestions
        };
    }

    /**
     * 分析 GN 文件（智能模式：优先使用 LLM，降级到传统解析）
     */
    async analyzeGNFile(sourceFilePath: string): Promise<GNAnalysisResult | null> {
        this.sendProgress(3, 20, '搜索 BUILD.gn 文件...');

        let gnPath = GNFileManager.findBuildGnFile(sourceFilePath);
        if (!gnPath) {
            // 增强：尝试多候选扫描（处理变量路径/聚合）
            const candidates = GNFileManager.findCandidateBuildGnsForSource(sourceFilePath, sourceFilePath);
            if (candidates.length > 0) {
                gnPath = candidates[0];
                Logger.info(`[Agent Mode] 使用候选 BUILD.gn: ${gnPath}`);
            }
        }
        if (!gnPath) {
            this.sendProgress(3, 100, '未找到 BUILD.gn 文件');
            return null;
        }

        // 尝试使用 LLM 分析
        if (this.useLLMAnalysis) {
            try {
                this.sendProgress(3, 40, '使用 AI 智能分析 GN 配置...');
                
                const fs = require('fs');
                const gnContent = fs.readFileSync(gnPath, 'utf-8');
                
                const llmResult = await this.llmAnalyzer.analyzeGNFileWithLLM(
                    gnPath,
                    gnContent,
                    sourceFilePath
                );
                
                this.sendProgress(3, 100, 'AI GN 分析完成');
                Logger.info(`[Agent Mode] LLM GN 分析成功`);
                return llmResult;
                
            } catch (error) {
                Logger.error(`[Agent Mode] LLM GN 分析失败: ${error}，降级到传统解析`);
                this.sendProgress(3, 50, 'AI 分析失败，使用传统方法...');
            }
        }

        // 降级到传统解析方法
        return this.analyzeGNFileTraditional(gnPath, sourceFilePath);
    }
    
    /**
     * 传统的 GN 文件分析方法（作为后备方案）
     */
    private async analyzeGNFileTraditional(
        gnPath: string,
        sourceFilePath: string
    ): Promise<GNAnalysisResult> {
        this.sendProgress(3, 50, '解析 GN 配置（传统方法）...');

        const gnDir = path.dirname(gnPath);
        const testDirectory = path.join(gnDir, 'test');

        this.sendProgress(3, 100, 'GN 分析完成（传统方法）');

        Logger.info(`[Agent Mode] 传统 GN 分析完成`);

        return {
            gnFilePath: gnPath,
            testTargets: [
                {
                    name: 'unittest',
                    type: 'ohos_unittest'
                }
            ],
            recommendation: {
                action: 'add-to-existing',
                targetName: 'unittest',
                testDirectory,
                reason: '传统解析：使用默认配置'
            }
        };
    }

    /**
     * 流式生成测试代码
     */
    async *generateTestStreaming(
        document: vscode.TextDocument,
        position: vscode.Position,
        analysis: CodeAnalysisResult,
        selectedText?: string,  // 选中的代码文本
        projectStructure?: ProjectStructure | null,  // 项目结构信息
        knowledgeBasePrompt?: string  // 工程知识库提示词
    ): AsyncGenerator<string> {
        this.sendProgress(4, 10, '准备生成提示词...');

        // 获取要测试的代码
        let codeToTest: string;
        let testFunctionNames: string[];
        
        if (selectedText) {
            Logger.info(`[generateTestStreaming] 📝 使用选中文本生成测试，长度: ${selectedText.length} 字符`);
            // 如果有选中文本，使用选中的代码（可能包含多个函数）
            codeToTest = selectedText;
            
            // 尝试提取所有函数名
            const functionTypes = await TreeSitter.getInstance().getFunctionTypes(document, false);
            const editor = vscode.window.activeTextEditor;
            
            if (editor && !editor.selection.isEmpty) {
                const selectionStart = editor.selection.start.line;
                const selectionEnd = editor.selection.end.line;
                
                Logger.info(`[generateTestStreaming] 📍 提取选中范围 [${selectionStart}, ${selectionEnd}] 内的函数`);
                
                // 修复：不仅提取函数名，还要提取函数的完整代码
                const selectedFunctions = functionTypes
                    ?.filter((f: any) => f.range.start.line <= selectionEnd && f.range.end.line >= selectionStart) || [];
                
                if (selectedFunctions.length > 0) {
                    testFunctionNames = selectedFunctions.map((f: any) => f.name);
                    codeToTest = selectedFunctions.map((f: any) => f.text).join('\n\n');
                    Logger.info(`[generateTestStreaming] ✅ 提取到 ${testFunctionNames.length} 个函数，代码总长度: ${codeToTest.length} 字符`);
                } else {
                    testFunctionNames = [analysis.functionName];
                }
            } else {
                Logger.warn(`[generateTestStreaming] ⚠️ 编辑器选区为空，使用分析结果中的函数名`);
                testFunctionNames = [analysis.functionName];
            }
            
            Logger.info(`[generateTestStreaming] 🎯 将为以下函数生成测试: ${testFunctionNames.join(', ')}`);
        } else {
            // 🆕 没有选中文本：提取所有公共函数（与 analyzeCode 保持一致）
            Logger.info(`[generateTestStreaming] 📝 没有选中文本，将提取所有公共函数`);
            
            const functionTypes = await TreeSitter.getInstance().getFunctionTypes(document, false);
            
            if (!functionTypes || functionTypes.length === 0) {
                Logger.error(`[generateTestStreaming] ❌ 文件中没有找到任何函数`);
                throw new Error('未找到任何函数');
            }
            
            // 🔍 过滤函数（与 analyzeCode 中的过滤逻辑保持一致）
            const publicFunctions = functionTypes.filter((func: any) => {
                const funcName = func.name.toLowerCase();
                
                // 排除规则：仅排除析构函数
                // 保留：私有函数、static 函数、helper 函数、internal 函数
                if (funcName.startsWith('~')) {
                    return false;
                }
                
                return true;
            });
            
            Logger.info(`[generateTestStreaming] 🎯 过滤后找到 ${publicFunctions.length} 个公共函数`);
            
            if (publicFunctions.length === 0) {
                // 回退：使用 analysis 中的单个函数
                Logger.warn(`[generateTestStreaming] ⚠️ 没有公共函数，回退到单个函数: ${analysis.functionName}`);
                const targetFunction = functionTypes.find((f: any) => f.name === analysis.functionName);
                
                if (!targetFunction) {
                    Logger.error(`[generateTestStreaming] ❌ 无法找到目标函数: ${analysis.functionName}`);
                    throw new Error('无法找到目标函数');
                }
                
                codeToTest = targetFunction.text;
                testFunctionNames = [analysis.functionName];
            } else {
                // ✅ 提取所有公共函数的代码
                testFunctionNames = publicFunctions.map((f: any) => f.name);
                codeToTest = publicFunctions.map((f: any) => f.text).join('\n\n');
                
                Logger.info(`[generateTestStreaming] ✅ 将为以下 ${testFunctionNames.length} 个公共函数生成测试:`);
                testFunctionNames.forEach((name, idx) => {
                    Logger.info(`[generateTestStreaming]   ${idx + 1}. ${name}`);
                });
                Logger.info(`[generateTestStreaming] 📏 总代码长度: ${codeToTest.length} 字符`);
            }
        }

        this.sendProgress(4, 30, '调用 LLM API...');

        // 构建提示词
        const prompt = await this.buildTestGenerationPrompt(
            testFunctionNames.length > 1 ? testFunctionNames.join(', ') : analysis.functionName,
            codeToTest,
            document.uri.fsPath,
            analysis,
            testFunctionNames.length,  // 传递函数数量
            projectStructure,  // 传递项目结构
            knowledgeBasePrompt,  // 传递工程知识库
            document  // 传递完整文档（用于提取被调用函数）
        );

        this.sendProgress(4, 50, '流式接收测试代码...');

        // 使用 LLM 流式生成
        // 智能选择最适合的模型
        const { ModelSelector } = await import('../../../../core/llm/modelSelector');
        const selectedModel = ModelSelector.selectModel('unitTest');
        
        let llm = this.llmFactory.getLLM(selectedModel);
        
        if (!llm) {
            // 尝试备用模型
            const fallbackModels = ModelSelector.getFallbackModels('unitTest');
            for (const fallbackModel of fallbackModels) {
                llm = this.llmFactory.getLLM(fallbackModel);
                if (llm) break;
            }
            
            if (!llm) {
                throw new Error('无法获取 LLM 实例（所有备用模型均不可用）');
            }
        }
        
        try {
            // 创建可取消的控制器
            this.currentAbortController = new AbortController();
            
            this.sendMessage({
                type: 'info',
                level: 'info',
                message: '💡 提示：生成过程中可以【⏸️ 暂停】查看内容或【❌ 取消】'
            });
            
            const stream = llm._streamChat([
                { role: 'system', content: '你是一个专业的 C++ 单元测试生成助手。' },
                { role: 'user', content: prompt }
            ], this.currentAbortController.signal);

            let buffer = '';
            let chunkCount = 0;
            for await (const chunk of stream) {
                // 1. 检查是否被取消
                if (this.currentAbortController?.signal.aborted) {
                    Logger.info('[generateTestStreaming] 检测到取消信号，停止生成');
                    throw new Error('用户取消操作');
                }
                
                // 2. 检查是否暂停 - 如果暂停，等待恢复
                await this.waitIfPaused();
                
                // 3. 正常处理
                if (chunk.content && typeof chunk.content === 'string') {
                    buffer += chunk.content;
                    chunkCount++;
                    yield chunk.content;
                }
            }

            // 🔍 记录完整的 LLM 返回结果
            Logger.info(`[generateTestStreaming] ✅ LLM 流式生成完成`);
            Logger.info(`[generateTestStreaming]    总 chunks: ${chunkCount}`);
            Logger.info(`[generateTestStreaming]    总字符数: ${buffer.length}`);
            Logger.info(`[generateTestStreaming] 📝 LLM 返回的完整代码（前 500 字符）:`);
            Logger.info(buffer.substring(0, 500).replace(/\n/g, '\n    '));
            Logger.info(`[generateTestStreaming] 📝 LLM 返回的完整代码（最后 300 字符）:`);
            Logger.info('    ...' + buffer.substring(Math.max(0, buffer.length - 300)).replace(/\n/g, '\n    '));

            this.sendProgress(4, 100, '测试代码生成完成');
        } catch (error: any) {
            if (error.name === 'AbortError' || error.message === '用户取消操作') {
                Logger.info('[generateTestStreaming] 操作被用户取消');
                this.sendMessage({
                    type: 'info',
                    level: 'warning',
                    message: '⚠️ 操作已取消'
                });
                throw new Error('操作已取消');
            }
            Logger.error(`流式生成失败: ${error}`);
            throw error;
        } finally {
            this.currentAbortController = null;
            this.isPaused = false;
            this.pausePromiseResolver = null;
        }
    }

    /**
     * 等待暂停结束（内部使用）
     */
    private async waitIfPaused(): Promise<void> {
        if (this.isPaused) {
            Logger.info('[waitIfPaused] 进入暂停等待状态...');
            // 创建一个Promise，等待resumeCurrentOperation调用
            await new Promise<void>((resolve) => {
                this.pausePromiseResolver = resolve;
            });
            Logger.info('[waitIfPaused] 暂停结束，继续生成');
        }
    }

    /**
     * 构建测试生成提示词（使用 OpenHarmony 规范 + 工程知识库 + 项目结构学习）
     */
    private async buildTestGenerationPrompt(
        functionName: string,
        functionCode: string,
        sourceFilePath: string,
        analysis: CodeAnalysisResult,
        functionCount: number = 1,  // 函数数量
        projectStructure?: ProjectStructure | null,  // 项目结构信息
        knowledgeBasePrompt?: string,  // 工程知识库提示词
        document?: vscode.TextDocument  // 完整文档（用于提取被调用函数）
    ): Promise<string> {
        // 🔍 智能上下文策略：根据文件大小决定提供完整文件还是函数调用链
        let enhancedFunctionCode = functionCode;
        let contextStrategy = 'single-function'; // 默认：仅单个函数
        
        if (document) {
            const fullText = document.getText();
            const lineCount = document.lineCount;
            
            // 策略1: 小文件（< 3000 行）→ 提供完整文件内容 + 依赖头文件
            if (lineCount < 3000) {
                Logger.info(`[buildTestGenerationPrompt] 📄 文件较小（${lineCount}行），提供完整文件内容给 LLM`);
                
                // 🔍 解析依赖的头文件
                let dependencyContext = '';
                try {
                    const { DependencyResolver } = await import('../DependencyResolver');
                    const dependencies = await DependencyResolver.resolveDependencies(
                        sourceFilePath,
                        fullText
                    );
                    
                    if (dependencies.length > 0) {
                        Logger.info(`[buildTestGenerationPrompt] 📎 找到 ${dependencies.length} 个依赖头文件`);
                        
                        // 格式化依赖
                        dependencyContext = `\n\n// ===== 依赖的头文件（${dependencies.length}个）=====\n`;
                        dependencyContext += `// 包含类定义、成员变量、函数声明等\n\n`;
                        
                        for (const dep of dependencies) {
                            dependencyContext += `// --- ${dep.type}: ${dep.fileName} ---\n`;
                            if (dep.content) {
                                // 限制头文件显示（避免过长）
                                const lines = dep.content.split('\n');
                                if (lines.length > 500) {
                                    dependencyContext += `${lines.slice(0, 500).join('\n')}\n`;
                                    dependencyContext += `// ... (头文件过长，已截断，共 ${lines.length} 行)\n\n`;
                                } else {
                                    dependencyContext += `${dep.content}\n\n`;
                                }
                            } else {
                                dependencyContext += `// (文件过大或无法读取)\n\n`;
                            }
                        }
                    }
                } catch (error) {
                    Logger.warn(`[buildTestGenerationPrompt] ⚠️ 依赖解析失败: ${error}`);
                }
                
                enhancedFunctionCode = `// ===== 完整文件内容 + 依赖 =====
// 主文件: ${path.basename(sourceFilePath)}
// 总行数: ${lineCount}
// 
// 说明：以下是完整的源文件内容及其依赖的头文件
// 主要测试目标是函数: ${functionName}
// LLM 可以看到：
// - 所有函数定义
// - 类定义和成员变量（来自头文件）
// - 函数调用关系
// - 全局变量和宏定义
//
// ===== 主文件代码开始 =====

${fullText}

// ===== 主文件代码结束 =====
${dependencyContext}
//
// 📌 主要测试目标函数：${functionName}
// 请重点为此函数生成测试，但可参考其他函数和头文件理解完整上下文
`;
                contextStrategy = 'full-file-with-deps';
            }
            // 策略2: 大文件（≥ 3000 行）→ 提取函数调用链 + 头文件
            else {
                Logger.info(`[buildTestGenerationPrompt] 📚 文件较大（${lineCount}行），提取函数调用链`);
                
                try {
                    const { FunctionCallChainExtractor } = await import('../FunctionCallChainExtractor');
                    const calledFunctions = await FunctionCallChainExtractor.extractCalledFunctions(
                        functionCode,
                        document
                    );
                    
                    if (calledFunctions.length > 0) {
                        Logger.info(`[buildTestGenerationPrompt] 🔗 检测到 ${calledFunctions.length} 个被调用函数`);
                        enhancedFunctionCode = FunctionCallChainExtractor.formatForLLM(
                            functionCode,
                            calledFunctions
                        );
                        contextStrategy = 'call-chain';
                    }
                    
                    // 🔍 为大文件也解析依赖头文件（类定义、成员变量）
                    try {
                        const { DependencyResolver } = await import('../DependencyResolver');
                        const dependencies = await DependencyResolver.resolveDependencies(
                            sourceFilePath,
                            fullText
                        );
                        
                        if (dependencies.length > 0) {
                            Logger.info(`[buildTestGenerationPrompt] 📎 找到 ${dependencies.length} 个依赖头文件`);
                            
                            let dependencyContext = `\n\n// ===== 依赖的头文件（${dependencies.length}个）=====\n`;
                            dependencyContext += `// 包含类定义、成员变量等\n\n`;
                            
                            for (const dep of dependencies) {
                                dependencyContext += `// --- ${dep.type}: ${dep.fileName} ---\n`;
                                if (dep.content) {
                                    const lines = dep.content.split('\n');
                                    if (lines.length > 300) {
                                        dependencyContext += `${lines.slice(0, 300).join('\n')}\n`;
                                        dependencyContext += `// ... (已截断，共 ${lines.length} 行)\n\n`;
                                    } else {
                                        dependencyContext += `${dep.content}\n\n`;
                                    }
                                } else {
                                    dependencyContext += `// (文件过大)\n\n`;
                                }
                            }
                            
                            enhancedFunctionCode += dependencyContext;
                            contextStrategy = 'call-chain-with-deps';
                        }
                    } catch (depError) {
                        Logger.warn(`[buildTestGenerationPrompt] ⚠️ 依赖解析失败: ${depError}`);
                    }
                } catch (error) {
                    Logger.warn(`[buildTestGenerationPrompt] ⚠️ 函数调用链提取失败: ${error}`);
                    // 继续使用原始代码
                }
            }
            
            Logger.info(`[buildTestGenerationPrompt] 📊 上下文策略: ${contextStrategy}`);
        }
        
        // 导入 OpenHarmony UT 生成器
        const { OpenHarmonyUTGenerator } = require('../OpenHarmonyUTGenerator');
        
        // 基础 prompt（使用增强后的函数代码）
        // ⭐ 会自动查找同文件其他函数的UT示例作为参考
        let basePrompt = OpenHarmonyUTGenerator.buildOHTestGenerationPrompt(
            functionName,
            enhancedFunctionCode,
            sourceFilePath,
            analysis.className,
            analysis.returnType
        );
        
        // 优先使用工程知识库（如果有）
        if (knowledgeBasePrompt && knowledgeBasePrompt.length > 0) {
            Logger.info(`[buildTestGenerationPrompt] 📚 添加工程知识库信息到 prompt`);
            Logger.info(`[buildTestGenerationPrompt]    知识库大小: ${(knowledgeBasePrompt.length / 1024).toFixed(2)} KB`);
            
            basePrompt = knowledgeBasePrompt + basePrompt;
        }
        // 否则使用实时项目结构分析（作为备用）
        else if (projectStructure) {
            const structureAnalyzer = new ProjectStructureAnalyzer();
            const structureInfo = structureAnalyzer.formatForLLM(projectStructure);
            
            Logger.info(`[buildTestGenerationPrompt] 📊 添加项目结构信息到 prompt（实时分析）`);
            Logger.info(`[buildTestGenerationPrompt]    测试文件模式: ${projectStructure.patterns.testFileNaming}`);
            Logger.info(`[buildTestGenerationPrompt]    测试目录: ${projectStructure.patterns.testDirectory}`);
            Logger.info(`[buildTestGenerationPrompt]    示例数量: ${projectStructure.existingTestExamples.length} 个测试文件, ${projectStructure.existingGNExamples.length} 个 GN 文件`);
            
            basePrompt = structureInfo + basePrompt;
        }
        
        // 如果是多个函数，添加额外的说明
        if (functionCount > 1) {
            // 在 prompt 前面添加多函数说明
            const multiFunctionNote = `
⚠️ **重要提示**：以下代码包含 ${functionCount} 个函数（${functionName}）。
请为**每个函数**分别生成完整的测试用例，确保所有函数都有对应的测试。

每个函数都需要：
1. 至少 3-5 个测试用例
2. 覆盖正常情况、边界条件和异常情况
3. 使用独立的 TEST_F 宏

---

`;
            basePrompt = multiFunctionNote + basePrompt;
            
            Logger.info(`[buildTestGenerationPrompt] 📝 添加了多函数生成提示（${functionCount}个函数）`);
        }
        
        // 【新增】提取现有测试文件上下文（如果存在）
        let existingTestContext = null;
        try {
            // 计算测试文件路径
            const testFilePath = this.inferTestFilePath(sourceFilePath);
            Logger.info(`[buildTestGenerationPrompt] 📄 检查测试文件是否存在: ${path.basename(testFilePath)}`);
            
            const { ExistingTestContextExtractor } = await import('../ExistingTestContextExtractor');
            existingTestContext = await ExistingTestContextExtractor.extractContext(testFilePath);
            
            if (existingTestContext.exists) {
                Logger.info(`[buildTestGenerationPrompt] ✅ 提取到现有测试上下文:`);
                Logger.info(`[buildTestGenerationPrompt]    - 测试类: ${existingTestContext.testClassName}`);
                Logger.info(`[buildTestGenerationPrompt]    - 成员变量: ${existingTestContext.memberVariables.length}个`);
                Logger.info(`[buildTestGenerationPrompt]    - 现有测试: ${existingTestContext.existingTests.length}个`);
                
                // 生成现有测试上下文的Prompt
                const contextPrompt = ExistingTestContextExtractor.generateContextPrompt(existingTestContext);
                // 将现有测试上下文插入到basePrompt最前面（最重要！）
                basePrompt = contextPrompt + '\n\n' + basePrompt;
                
                Logger.info(`[buildTestGenerationPrompt] 📝 已添加现有测试文件上下文到Prompt（${(contextPrompt.length / 1024).toFixed(2)} KB）`);
            } else {
                Logger.info(`[buildTestGenerationPrompt] ℹ️ 这是新建的测试文件，无现有上下文`);
            }
        } catch (contextError) {
            Logger.warn(`[buildTestGenerationPrompt] ⚠️ 现有测试上下文提取失败: ${contextError}`);
            // 继续执行，不影响正常流程
        }
        
        // 🔮 使用Prompt增强器（自动选择轻量级或完整版）
        try {
            // 使用新的增强器选择器（会根据环境自动选择合适的增强器）
            let enhancedPrompt = PromptEnhancerSelector.enhancePrompt(
                basePrompt,
                functionCode,
                functionName
            );
            
            return enhancedPrompt;
        } catch (error) {
            Logger.error('[buildTestGenerationPrompt] ⚠️ Prompt增强失败，使用原始Prompt: ' + (error instanceof Error ? error.message : String(error)));
            return basePrompt;
        }
    }

    /**
     * 推断测试文件路径
     * 
     * 规则：
     * - 源文件：xxx/src/yyy.cpp  → 测试文件：xxx/test/unittest/yyy_test.cpp
     * - 源文件：xxx/yyy.cpp      → 测试文件：xxx/test/unittest/yyy_test.cpp
     */
    private inferTestFilePath(sourceFilePath: string): string {
        const parsedPath = path.parse(sourceFilePath);
        const baseName = parsedPath.name;  // 文件名（不含扩展名）
        const dir = parsedPath.dir;
        
        // 规则1：如果路径包含/src/，替换为/test/unittest/
        if (dir.includes(path.sep + 'src' + path.sep)) {
            const testDir = dir.replace(path.sep + 'src' + path.sep, path.sep + 'test' + path.sep + 'unittest' + path.sep);
            return path.join(testDir, `${baseName}_test.cpp`);
        }
        
        // 规则2：如果路径包含/services/，替换为/test/unittest/
        if (dir.includes(path.sep + 'services' + path.sep)) {
            const testDir = dir.replace(path.sep + 'services' + path.sep, path.sep + 'test' + path.sep + 'unittest' + path.sep);
            return path.join(testDir, `${baseName}_test.cpp`);
        }
        
        // 规则3：默认在同级目录下的test/unittest/
        const projectRoot = dir.split(path.sep).slice(0, -1).join(path.sep);  // 向上一级
        return path.join(projectRoot, 'test', 'unittest', `${baseName}_test.cpp`);
    }
    
    /**
     * 分析函数复杂度
     */
    private analyzeComplexity(
        func: any
    ): 'simple' | 'medium' | 'complex' {
        const code = func.text || '';

        // 简单的复杂度分析
        const lineCount = func.range ? (func.range.end.line - func.range.start.line) : 0;
        const ifCount = (code.match(/\bif\b/g) || []).length;
        const loopCount = (code.match(/\b(for|while)\b/g) || []).length;

        if (lineCount > 50 || ifCount > 5 || loopCount > 3) {
            return 'complex';
        } else if (lineCount > 20 || ifCount > 2 || loopCount > 1) {
            return 'medium';
        } else {
            return 'simple';
        }
    }

    /**
     * 发送进度消息
     */
    private sendProgress(step: number, progress: number, message: string): void {
        this.sendMessage({
            type: 'step-progress',
            step,
            progress,
            message
        });
    }

    /**
     * 暂停当前操作
     */
    public pauseCurrentOperation(): void {
        if (this.currentAbortController && !this.isPaused) {
            this.isPaused = true;
            Logger.info('[Agent Mode] ⏸️  用户暂停操作');
            
            this.sendMessage({
                type: 'info',
                level: 'warning',
                message: '⏸️  已暂停 - 您可以查看当前内容，选择【▶️ 继续】或【❌ 取消】'
            });
        } else if (this.isPaused) {
            Logger.warn('[Agent Mode] 操作已经在暂停状态');
        } else {
            Logger.warn('[Agent Mode] 没有正在进行的操作可以暂停');
        }
    }

    /**
     * 继续当前操作
     */
    public resumeCurrentOperation(): void {
        if (this.isPaused) {
            this.isPaused = false;
            
            // 触发恢复
            if (this.pausePromiseResolver) {
                this.pausePromiseResolver();
                this.pausePromiseResolver = null;
            }
            
            Logger.info('[Agent Mode] ▶️  用户继续操作');
            
            this.sendMessage({
                type: 'info',
                level: 'success',
                message: '▶️  继续生成中...'
            });
        } else {
            Logger.warn('[Agent Mode] 操作未暂停，无需继续');
        }
    }

    /**
     * 取消当前正在进行的操作
     */
    public cancelCurrentOperation(): void {
        if (this.currentAbortController) {
            Logger.info('[Agent Mode] ❌ 用户取消操作');
            
            // 如果正在暂停，先恢复再取消
            if (this.isPaused && this.pausePromiseResolver) {
                this.pausePromiseResolver();
                this.pausePromiseResolver = null;
            }
            
            this.isPaused = false;
            this.currentAbortController.abort();
            this.currentAbortController = null;
            
            this.sendMessage({
                type: 'info',
                level: 'warning',
                message: '❌ 操作已取消'
            });
        } else {
            Logger.warn('[Agent Mode] 没有正在进行的操作可以取消');
        }
    }

    /**
     * 获取当前状态
     */
    public getCurrentState(): { isRunning: boolean; isPaused: boolean } {
        return {
            isRunning: this.currentAbortController !== null,
            isPaused: this.isPaused
        };
    }

    /**
     * 查找项目根目录（包含 bundle.json 的目录）
     */
    private findProjectRoot(startPath: string): string {
        let currentPath = path.dirname(startPath);
        const root = path.parse(currentPath).root;
        let depth = 0;
        
        while (currentPath !== root && depth < 10) {
            const bundleJsonPath = path.join(currentPath, 'bundle.json');
            if (require('fs').existsSync(bundleJsonPath)) {
                return currentPath;
            }
            currentPath = path.dirname(currentPath);
            depth++;
        }
        
        // 如果找不到 bundle.json，返回工作区根目录
        const workspaceFolder = vscode.workspace.getWorkspaceFolder(vscode.Uri.file(startPath));
        return workspaceFolder ? workspaceFolder.uri.fsPath : path.dirname(startPath);
    }
    
    async execute(
        document: vscode.TextDocument,
        position: vscode.Position,
        selectedText?: string  // 新增：选中的代码文本
    ): Promise<{
        testCode: string;
        testFilePath: string;
        gnChanges?: any;
    }> {
        // 保存上下文，用于后续对话优化
        this.currentDocument = document;
        this.currentPosition = position;
        
        // 初始化对话历史
        this.conversationHistory = [
            {
                role: 'system' as const,
                content: '你是一个专业的 C++ 单元测试生成助手，遵循 OpenHarmony 规范。'
            }
        ];
        
        const workspaceFolder = vscode.workspace.getWorkspaceFolder(document.uri);
        const workspaceRoot = workspaceFolder ? workspaceFolder.uri.fsPath : path.dirname(document.uri.fsPath);
        
        // 查找项目根目录
        const projectRoot = this.findProjectRoot(document.uri.fsPath);

        // 步骤 0a: 尝试加载工程知识库（优先级最高）
        Logger.info(`[Agent Execute] 📚 尝试加载工程知识库`);
        let knowledgeBasePrompt = '';
        
        try {
            const { ProjectKnowledgeManager } = require('../ProjectKnowledgeBase/ProjectKnowledgeManager');
            const knowledgeManager = ProjectKnowledgeManager.getInstance();
            const kb = await knowledgeManager.getKnowledgeBase();
            
            if (kb) {
                Logger.info(`[Agent Execute] ✅ 成功加载工程知识库`);
                Logger.info(`[Agent Execute]    包含 ${kb.projects.length} 个工程的知识`);
                Logger.info(`[Agent Execute]    最后更新: ${kb.lastUpdated}`);
                
                knowledgeBasePrompt = knowledgeManager.formatForLLM(document.uri.fsPath, kb);
            } else {
                Logger.info(`[Agent Execute] ℹ️ 未找到工程知识库，将使用实时分析`);
            }
        } catch (error) {
            Logger.warn(`[Agent Execute] ⚠️ 加载工程知识库失败: ${error}`);
        }
        
        // 步骤 0b: 实时分析项目结构（作为补充或备用）
        Logger.info(`[Agent Execute] 📊 开始分析当前项目结构`);
        let projectStructure: ProjectStructure | null = null;
        
        try {
            const structureAnalyzer = new ProjectStructureAnalyzer();
            projectStructure = await structureAnalyzer.analyzeProjectStructure(document.uri.fsPath);
            Logger.info(`[Agent Execute] ✅ 项目结构分析完成`);
            Logger.info(`[Agent Execute]    找到 ${projectStructure.existingTestExamples.length} 个测试文件示例`);
            Logger.info(`[Agent Execute]    找到 ${projectStructure.existingGNExamples.length} 个 GN 文件示例`);
        } catch (error) {
            Logger.warn(`[Agent Execute] ⚠️ 项目结构分析失败，将继续使用默认流程: ${error}`);
        }

        // 步骤 1: 分析代码
        this.sendMessage({
            type: 'info',
            level: 'info',
            message: '🔍 步骤 1/6: 分析代码结构和项目规范...'
        });
        const codeAnalysis = await this.analyzeCode(document, position, selectedText);
        
        this.sendMessage({
            type: 'info',
            level: 'success',
            message: `✅ 找到函数: \`${codeAnalysis.functionName}\``
        });

        // 步骤 2: 分析依赖
        this.sendMessage({
            type: 'info',
            level: 'info',
            message: '📦 步骤 2/6: 分析依赖关系...'
        });
        const dependencies = await this.analyzeDependencies(document);
        
        // 列出依赖项
        let depsMessage = '✅ 依赖分析完成\n\n';
        if (dependencies.includes && dependencies.includes.length > 0) {
            depsMessage += `**头文件** (${dependencies.includes.length} 个):\n`;
            dependencies.includes.slice(0, 5).forEach(header => {
                depsMessage += `- \`${header}\`\n`;
            });
            if (dependencies.includes.length > 5) {
                depsMessage += `- ... 还有 ${dependencies.includes.length - 5} 个\n`;
            }
        }
        if (dependencies.externalDependencies && dependencies.externalDependencies.length > 0) {
            depsMessage += `\n**外部依赖** (${dependencies.externalDependencies.length} 个):\n`;
            dependencies.externalDependencies.forEach(dep => {
                depsMessage += `- \`${dep.name}\` (${dep.type})\n`;
            });
        }
        
        this.sendMessage({
            type: 'info',
            level: 'success',
            message: depsMessage
        });

        // 步骤 3: 查找源文件的 BUILD.gn
        this.sendMessage({
            type: 'info',
            level: 'info',
            message: '🔧 步骤 3/6: 查找源文件的 GN 配置...'
        });
        
        // 使用 ProjectAnalyzer 查找包含当前源文件的 BUILD.gn（支持兄弟目录等复杂场景）
        let sourceBuildGn: string | null = null;
        let sourceFileInfo: any = null;  // 保存 ProjectAnalyzer 的分析结果
        
        try {
            Logger.info(`[Agent Execute] 🔍 使用 ProjectAnalyzer 查找源文件的 BUILD.gn...`);
            const projectAnalyzer = new ProjectAnalyzer();
            sourceFileInfo = await projectAnalyzer.analyzeSourceFile(document.uri.fsPath);
            
            if (sourceFileInfo.sourceBuildGN) {
                sourceBuildGn = sourceFileInfo.sourceBuildGN.filePath;
                Logger.info(`[Agent Execute] ✅ ProjectAnalyzer 找到源文件的 BUILD.gn: ${sourceBuildGn}`);
                Logger.info(`[Agent Execute]    目标数量: ${sourceFileInfo.sourceBuildGN.targets.length}`);
                for (const target of sourceFileInfo.sourceBuildGN.targets) {
                    Logger.info(`[Agent Execute]      - ${target.name} (${target.type})`);
                }
            } else {
                Logger.warn(`[Agent Execute] ⚠️ ProjectAnalyzer 未找到源文件的 BUILD.gn`);
            }
        } catch (error) {
            Logger.error(`[Agent Execute] ❌ ProjectAnalyzer 查找失败: ${error}`);
            Logger.error(`[Agent Execute]    ${error}`);
        }
        
        if (sourceBuildGn) {
            const gnRelativePath = path.relative(projectRoot, sourceBuildGn).replace(/\\/g, '/');
            this.sendMessage({
                type: 'info',
                level: 'success',
                message: `✅ 找到源文件的 GN 配置文件\n\n该文件的 sources 中包含当前源文件`
            });
            
            // 发送文件信息，带查看按钮
            Logger.info(`[Agent Execute] 📤 发送源文件 GN 信息: ${gnRelativePath}`);
            this.sendMessage({
                type: 'file-info',
                fileType: 'source-gn',
                filePath: sourceBuildGn,
                displayPath: gnRelativePath,
                label: '源文件 GN 配置'
            });
        } else {
            this.sendMessage({
                type: 'info',
                level: 'warning',
                message: '⚠️ 未找到包含当前源文件的 GN 配置文件'
            });
        }

        // 步骤 4: 生成测试代码
        this.sendMessage({
            type: 'info',
            level: 'info',
            message: '✨ 步骤 4/6: 生成单元测试代码...'
        });

        let fullTestCode = '';
        for await (const chunk of this.generateTestStreaming(document, position, codeAnalysis, selectedText, projectStructure, knowledgeBasePrompt)) {
            fullTestCode += chunk;
            this.sendMessage({
                type: 'code-chunk',
                content: chunk
            });
        }

        // 🔍 记录收集到的完整代码
        Logger.info(`[Agent Execute] ✅ 完整测试代码收集完成`);
        Logger.info(`[Agent Execute]    总字符数: ${fullTestCode.length}`);
        Logger.info(`[Agent Execute] 📝 收集到的完整代码（前 500 字符）:`);
        Logger.info(fullTestCode.substring(0, 500).replace(/\n/g, '\n    '));
        Logger.info(`[Agent Execute] 📝 收集到的完整代码（最后 300 字符）:`);
        Logger.info('    ...' + fullTestCode.substring(Math.max(0, fullTestCode.length - 300)).replace(/\n/g, '\n    '));

        this.currentTestCode = fullTestCode;

        // 步骤 5: 确定测试文件路径和测试 GN
        this.sendMessage({
            type: 'info',
            level: 'info',
            message: '📝 步骤 5/6: 确定测试文件路径和 GN 配置...'
        });
        
        // 获取不带扩展名的源文件名，用于生成测试文件名
        const testFileBaseName = path.basename(document.uri.fsPath, path.extname(document.uri.fsPath));
        
        // 智能查找测试目录（初始化为默认值）
        const root = path.parse(document.uri.fsPath).root;
        const sourceDir = path.dirname(document.uri.fsPath);
        let testFilePath: string = path.join(sourceDir, 'test', `${testFileBaseName}_test.cpp`);  // 默认值
        let testBuildGnPath: string | undefined;
        
        Logger.info(`[Agent Execute] 📂 开始查找测试目录...`);
        Logger.info(`[Agent Execute]    源文件: ${document.uri.fsPath}`);
        Logger.info(`[Agent Execute]    项目根: ${projectRoot}`);
        Logger.info(`[Agent Execute]    选中文本: ${selectedText ? '是 (' + selectedText.length + ' 字符)' : '否（全文件）'}`);
        if (sourceBuildGn) {
            Logger.info(`[Agent Execute]    源 GN: ${sourceBuildGn}`);
        }
        
        let testDirFound = false;
        
        // 策略1: 从项目根目录查找 test/unittest，优先选择已有 BUILD.gn 的目录
        if (projectRoot) {
            const projectTestDirs = [
                path.join(projectRoot, 'test', 'unittest'),
                path.join(projectRoot, 'test')
            ];
            
            // 第一轮：优先查找已有 BUILD.gn 的目录
            for (const testDir of projectTestDirs) {
                const buildGnPath = path.join(testDir, 'BUILD.gn');
                if (require('fs').existsSync(testDir) && require('fs').existsSync(buildGnPath)) {
                    testFilePath = path.join(testDir, `${testFileBaseName}_test.cpp`);
                    testBuildGnPath = buildGnPath;
                    Logger.info(`[Agent Execute] ✅ 策略1成功 (已有GN): ${testDir}`);
                    Logger.info(`[Agent Execute]    → 将修改现有 BUILD.gn`);
                    testDirFound = true;
                    break;
                }
            }
            
            // 第二轮：如果没有找到已有GN的目录，找任意存在的test目录
            if (!testDirFound) {
                for (const testDir of projectTestDirs) {
                    if (require('fs').existsSync(testDir)) {
                        testFilePath = path.join(testDir, `${testFileBaseName}_test.cpp`);
                        testBuildGnPath = path.join(testDir, 'BUILD.gn');
                        Logger.info(`[Agent Execute] ✅ 策略1成功 (无GN): ${testDir}`);
                        Logger.info(`[Agent Execute]    → 将新建 BUILD.gn`);
                        testDirFound = true;
                        break;
                    }
                }
            }
        }
        
        // 策略2: 从源文件所在目录或GN所在目录向上查找 test 目录，优先已有 BUILD.gn
        if (!testDirFound) {
            const startDir = sourceBuildGn ? path.dirname(sourceBuildGn) : path.dirname(document.uri.fsPath);
            let searchDir = startDir;
            let depth = 0;
            
            Logger.info(`[Agent Execute] 📁 策略2: 从 ${startDir} 向上查找...`);
            
            // 先收集所有候选目录
            const allCandidates: Array<{dir: string, hasGn: boolean}> = [];
            
            while (searchDir !== root && depth < 5) {
                const candidateDirs = [
                    path.join(searchDir, 'test', 'unittest'),
                    path.join(searchDir, 'test')
                ];
                
                for (const testDir of candidateDirs) {
                    if (require('fs').existsSync(testDir)) {
                        const buildGnPath = path.join(testDir, 'BUILD.gn');
                        const hasGn = require('fs').existsSync(buildGnPath);
                        allCandidates.push({ dir: testDir, hasGn });
                    }
                }
                
                searchDir = path.dirname(searchDir);
                depth++;
            }
            
            // 优先选择有BUILD.gn的目录
            let selectedTestDir = allCandidates.find(c => c.hasGn);
            if (!selectedTestDir && allCandidates.length > 0) {
                selectedTestDir = allCandidates[0]; // 没有GN的，选第一个
            }
            
            if (selectedTestDir) {
                testFilePath = path.join(selectedTestDir.dir, `${testFileBaseName}_test.cpp`);
                testBuildGnPath = path.join(selectedTestDir.dir, 'BUILD.gn');
                Logger.info(`[Agent Execute] ✅ 策略2成功 ${selectedTestDir.hasGn ? '(已有GN)' : '(无GN)'}: ${selectedTestDir.dir}`);
                Logger.info(`[Agent Execute]    相对项目根: ${path.relative(projectRoot, selectedTestDir.dir)}`);
                Logger.info(`[Agent Execute]    → 将${selectedTestDir.hasGn ? '修改' : '新建'} BUILD.gn`);
                testDirFound = true;
            }
        }
        
        // 策略3: 后备方案 - 在项目根创建 test/unittest 目录（推荐），或使用源文件相邻目录
        if (!testDirFound) {
            Logger.info(`[Agent Execute] 📁 策略3: 后备方案`);
            
            if (projectRoot) {
                // 优先在项目根创建 test/unittest 目录（标准目录结构）
                const preferredTestDir = path.join(projectRoot, 'test', 'unittest');
                testFilePath = path.join(preferredTestDir, `${testFileBaseName}_test.cpp`);
                testBuildGnPath = path.join(preferredTestDir, 'BUILD.gn');
                
                Logger.info(`[Agent Execute]    ✅ 将在项目根创建标准测试目录`);
                Logger.info(`[Agent Execute]    测试目录: ${preferredTestDir}`);
                Logger.info(`[Agent Execute]    相对路径: ${path.relative(projectRoot, preferredTestDir)}`);
                Logger.info(`[Agent Execute]    → 将新建 BUILD.gn`);
            } else {
                // 如果没有项目根，使用源文件相邻的 test 目录
                Logger.warn(`[Agent Execute]    ⚠️ 未找到项目根，使用源文件相邻目录`);
                const sourceDir = path.dirname(document.uri.fsPath);
                const adjacentTestDir = path.join(sourceDir, 'test');
                testFilePath = path.join(adjacentTestDir, `${testFileBaseName}_test.cpp`);
                testBuildGnPath = path.join(adjacentTestDir, 'BUILD.gn');
                
                Logger.info(`[Agent Execute]    测试目录: ${adjacentTestDir}`);
                Logger.info(`[Agent Execute]    → 将新建 BUILD.gn`);
            }
        }
        
        // === 新增：检测并处理分层测试目录结构（group + 子模块） ===
        let needsSubdirectory = false;
        let testModuleName: string | undefined;
        let parentGroupGnPath: string | undefined;
        
        if (testBuildGnPath && require('fs').existsSync(testBuildGnPath)) {
            try {
                const content = require('fs').readFileSync(testBuildGnPath, 'utf-8');
                
                // 检测是否是 group 结构（包含 group( 但不包含 ohos_unittest(）
                if (content.includes('group(') && !content.includes('ohos_unittest(')) {
                    Logger.info(`[Agent Execute] 🔍 检测到 group 结构的 BUILD.gn，需要创建子模块目录`);
                    needsSubdirectory = true;
                    parentGroupGnPath = testBuildGnPath; // 保存父级 group 的路径
                    
                    // 推断模块名：从源文件路径提取
                    // 例如: .../managersource/src/xxx.cpp -> managersource
                    const sourceDir = path.dirname(document.uri.fsPath);
                    const sourceDirName = path.basename(sourceDir); // 可能是 "src"
                    
                    if (sourceDirName === 'src' || sourceDirName === 'source') {
                        // 上一级目录就是模块名
                        testModuleName = path.basename(path.dirname(sourceDir));
                    } else {
                        // 当前目录就是模块名
                        testModuleName = sourceDirName;
                    }
                    
                    Logger.info(`[Agent Execute] 📦 推断的模块名: ${testModuleName}`);
                    
                    // 构建子模块目录路径
                    const testParentDir = path.dirname(testBuildGnPath);
                    const testSubDir = path.join(testParentDir, testModuleName);
                    
                    // 更新测试文件路径和 GN 路径到子目录
                    testFilePath = path.join(testSubDir, 'src', `${testFileBaseName}_test.cpp`);
                    testBuildGnPath = path.join(testSubDir, 'BUILD.gn');
                    
                    Logger.info(`[Agent Execute] 📁 子模块目录: ${testSubDir}`);
                    Logger.info(`[Agent Execute]    测试文件: ${testFilePath}`);
                    Logger.info(`[Agent Execute]    子模块 GN: ${testBuildGnPath}`);
                }
            } catch (error) {
                Logger.warn(`[Agent Execute] ⚠️ 检测分层结构时出错: ${error}`);
            }
        }
        
        Logger.info(`[Agent Execute] 📝 最终确定:`);
        Logger.info(`[Agent Execute]    测试文件: ${testFilePath}`);
        Logger.info(`[Agent Execute]    测试 GN: ${testBuildGnPath || '（未设置）'}`);
        Logger.info(`[Agent Execute]    是否分层结构: ${needsSubdirectory ? '是' : '否'}`);
        if (needsSubdirectory) {
            Logger.info(`[Agent Execute]    模块名: ${testModuleName}`);
            Logger.info(`[Agent Execute]    父级 group GN: ${parentGroupGnPath}`);
        }
        
        const testRelativePath = path.relative(projectRoot, testFilePath).replace(/\\/g, '/');
        let testGnRelativePath: string | undefined;
        
        // 检查 GN 文件是否已存在
        const testGnExists = testBuildGnPath && require('fs').existsSync(testBuildGnPath);
        
        this.sendMessage({
            type: 'info',
            level: 'success',
            message: `✅ 确定测试文件路径和配置\n\n` +
                    (testGnExists 
                        ? `📝 将**修改**现有的 BUILD.gn 文件` 
                        : `📝 将**新建** BUILD.gn 文件`)
        });
        
        // 发送测试文件信息
        Logger.info(`[Agent Execute] 📤 发送测试文件信息: ${testRelativePath}`);
        Logger.info(`[Agent Execute]    文件路径: ${testFilePath}`);
        this.sendMessage({
            type: 'file-info',
            fileType: 'test-file',
            filePath: testFilePath,
            displayPath: testRelativePath,
            label: '测试文件路径'
        });
        
        if (testBuildGnPath) {
            testGnRelativePath = path.relative(projectRoot, testBuildGnPath).replace(/\\/g, '/');
            // 发送测试GN信息
            Logger.info(`[Agent Execute] 📤 发送测试 GN 信息: ${testGnRelativePath}`);
            Logger.info(`[Agent Execute]    文件路径: ${testBuildGnPath}`);
            this.sendMessage({
                type: 'file-info',
                fileType: 'test-gn',
                filePath: testBuildGnPath,
                displayPath: testGnRelativePath,
                label: '测试 GN 配置'
            });
        } else {
            Logger.warn(`[Agent Execute] ⚠️ 没有测试 GN 文件需要发送`);
        }

        // 步骤 6: 完成并提供文件操作选项或自动创建
        const config = vscode.workspace.getConfiguration('harmonypilot');
        const autoCreateFiles = config.get<boolean>('unitTest.autoCreateFiles', false);
        
        Logger.info(`[Agent Execute] 📋 配置：autoCreateFiles = ${autoCreateFiles}`);
        
        if (autoCreateFiles) {
            // 自动创建模式：直接创建文件
            this.sendMessage({
                type: 'info',
                level: 'success',
                message: '✅ 步骤 6/6: 测试代码生成完成！\n\n正在自动创建文件...'
            });
            
            try {
                const fs = require('fs');
                
                // 1. 创建测试文件（如果是分层结构，会创建 src/ 和 include/）
                const testDir = path.dirname(testFilePath);
                if (!fs.existsSync(testDir)) {
                    fs.mkdirSync(testDir, { recursive: true });
                    Logger.info(`[Agent Execute] 📁 创建测试目录: ${testDir}`);
                }
                
                // 如果是分层结构，还要创建 include/ 目录
                if (needsSubdirectory && testModuleName) {
                    const testSubDir = path.dirname(testDir); // src 的父目录
                    const includeDir = path.join(testSubDir, 'include');
                    if (!fs.existsSync(includeDir)) {
                        fs.mkdirSync(includeDir, { recursive: true });
                        Logger.info(`[Agent Execute] 📁 创建 include 目录: ${includeDir}`);
                    }
                }
                
                // 🔍 写入文件前记录要写入的代码
                Logger.info(`[Agent Execute] 📤 准备写入测试文件: ${testFilePath}`);
                Logger.info(`[Agent Execute]    代码长度: ${fullTestCode.length} 字符`);
                Logger.info(`[Agent Execute] 📝 要写入的代码（前 500 字符）:`);
                Logger.info(fullTestCode.substring(0, 500).replace(/\n/g, '\n    '));
                
                // ✅ 使用智能追加器，避免覆盖用户代码
                const { TestFileAppender } = require('../TestFileAppender');
                const result = await TestFileAppender.writeTestFile(testFilePath, fullTestCode, {
                    forceOverwrite: false  // 追加模式，不覆盖（git管理版本）
                });
                
                // 🔍 记录写入结果
                Logger.info(`[Agent Execute] ${result.success ? '✅' : '⚠️'} 文件写入结果:`);
                Logger.info(`[Agent Execute]    操作: ${result.action}`);
                Logger.info(`[Agent Execute]    消息: ${result.message}`);
                
                if (result.success) {
                    Logger.info(`[Agent Execute] ✅ 测试文件${result.action === 'created' ? '已创建' : '已更新'}: ${testFilePath}`);
                    
                    this.sendMessage({
                        type: 'info',
                        level: 'success',
                        message: `✅ 测试文件${result.action === 'appended' ? '已追加' : '已创建'}: \`${testRelativePath}\``
                    });
                } else {
                    Logger.warn(`[Agent Execute] ⚠️ ${result.message}`);
                    
                    this.sendMessage({
                        type: 'info',
                        level: 'warning',
                        message: `⚠️ ${result.message}`
                    });
                }
                
                // 2. 创建/修改 GN 文件（如果有）
                if (testBuildGnPath) {
                    Logger.info(`[Agent Execute] 📝 开始处理 GN 文件: ${testBuildGnPath}`);
                    
                    const testFileName = path.basename(testFilePath);
                    
                    if (fs.existsSync(testBuildGnPath)) {
                        // GN 文件已存在，添加测试文件到 sources
                        Logger.info(`[Agent Execute] 📝 GN 文件已存在，修改现有文件`);
                        
                        this.sendMessage({
                            type: 'info',
                            level: 'info',
                            message: `📝 检测到现有 BUILD.gn，正在添加测试文件到 sources...`
                        });
                        
                        const result = GNFileManager.addTestFile(testBuildGnPath, testFileName);
                        if (result.success) {
                            GNFileManager.applyChanges(testBuildGnPath, result.newContent);
                            this.sendMessage({
                                type: 'info',
                                level: 'success',
                                message: `✅ 已**修改**现有 GN 文件: \`${testGnRelativePath}\`\n   添加了 \`${testFileName}\` 到 sources`
                            });
                        } else {
                            // 检查是否是"文件已存在"的情况（这是正常的，无需警告）
                            if (result.message && result.message.includes('已存在于BUILD.gn')) {
                                Logger.info(`[Agent Execute] ℹ️ 测试文件已在 GN 中，跳过添加: ${result.message}`);
                                this.sendMessage({
                                    type: 'info',
                                    level: 'info',
                                    message: `ℹ️ 测试文件 \`${testFileName}\` 已在 BUILD.gn 的 sources 中（无需重复添加）`
                                });
                            } else {
                                Logger.warn(`[Agent Execute] ⚠️ 修改 GN 文件失败: ${result.message}`);
                                this.sendMessage({
                                    type: 'info',
                                    level: 'warning',
                                    message: `⚠️ 修改 GN 文件失败: ${result.message || '未知错误'}\n   请手动检查 BUILD.gn 文件`
                                });
                            }
                        }
                    } else {
                        // GN 文件不存在，创建新的 GN 文件
                        Logger.info(`[Agent Execute] 📝 GN 文件不存在，创建新的 GN 文件`);
                        Logger.info(`[Agent Execute]    是否分层结构: ${needsSubdirectory ? '是' : '否'}`);
                        
                        this.sendMessage({
                            type: 'info',
                            level: 'info',
                            message: `📝 未检测到 BUILD.gn，正在生成新文件...${needsSubdirectory ? '（子模块结构）' : ''}`
                        });
                        
                        const gnDir = path.dirname(testBuildGnPath);
                        if (!fs.existsSync(gnDir)) {
                            fs.mkdirSync(gnDir, { recursive: true });
                            Logger.info(`[Agent Execute] 📁 创建 GN 目录: ${gnDir}`);
                        }
                        
                        // 从 ProjectAnalyzer 的结果中提取源文件的 GN 配置
                        let sourceGNConfig = null;
                        if (sourceFileInfo && sourceFileInfo.sourceBuildGN && sourceFileInfo.sourceBuildGN.targets.length > 0) {
                            this.sendMessage({
                                type: 'info',
                                level: 'info',
                                message: '📦 正在从源文件的 GN 配置中提取 deps、includes 等信息...'
                            });
                            
                            // 找到包含当前源文件的 target
                            const sourceFileName = path.basename(document.uri.fsPath);
                            const normalizedFilePath = path.normalize(document.uri.fsPath).toLowerCase().replace(/\\/g, '/');
                            
                            let matchedTarget = null;
                            for (const target of sourceFileInfo.sourceBuildGN.targets) {
                                for (const source of target.sources) {
                                    const normalizedSource = path.normalize(source).toLowerCase().replace(/\\/g, '/');
                                    if (normalizedSource === normalizedFilePath || path.basename(source) === sourceFileName) {
                                        matchedTarget = target;
                                        break;
                                    }
                                }
                                if (matchedTarget) break;
                            }
                            
                            if (matchedTarget) {
                                // 直接使用 ProjectAnalyzer 解析的配置（已经处理了GN变量）
                                sourceGNConfig = {
                                    deps: matchedTarget.deps || [],
                                    include_dirs: matchedTarget.include_dirs || [],
                                    external_deps: matchedTarget.external_deps || [],
                                    cflags_cc: [],
                                    configs: matchedTarget.configs || [],
                                    public_configs: [],
                                    defines: matchedTarget.defines || [],
                                    module_out_path: '',
                                    part_name: '',
                                    subsystem_name: ''
                                };
                                
                                Logger.info(`[Agent Execute] ✅ 成功提取源文件 GN 配置 (来自 ProjectAnalyzer)`);
                                Logger.info(`[Agent Execute]    target: ${matchedTarget.name}`);
                                Logger.info(`[Agent Execute]    deps: ${sourceGNConfig.deps.length} 项`);
                                Logger.info(`[Agent Execute]    include_dirs: ${sourceGNConfig.include_dirs.length} 项`);
                                Logger.info(`[Agent Execute]    external_deps: ${sourceGNConfig.external_deps.length} 项`);
                                
                                this.sendMessage({
                                    type: 'info',
                                    level: 'success',
                                    message: `✅ 已提取源文件配置 (目标: ${matchedTarget.name}):\n` +
                                            `   - deps: ${sourceGNConfig.deps.length} 项\n` +
                                            `   - include_dirs: ${sourceGNConfig.include_dirs.length} 项\n` +
                                            `   - external_deps: ${sourceGNConfig.external_deps.length} 项`
                                });
                            } else {
                                Logger.warn(`[Agent Execute] ⚠️ 未能在 BUILD.gn 中找到包含当前源文件的 target`);
                                this.sendMessage({
                                    type: 'info',
                                    level: 'warning',
                                    message: '⚠️ 未能找到包含当前源文件的 target，将使用基本模板'
                                });
                            }
                        }
                        
                        // 生成完整的测试 BUILD.gn 内容
                        let gnContent: string;
                        const sourceDir = path.dirname(document.uri.fsPath);
                        
                        if (needsSubdirectory && testModuleName) {
                            // === 分层结构：生成子模块专用的 BUILD.gn ===
                            Logger.info(`[Agent Execute] 🔨 生成子模块 BUILD.gn (分层结构)`);
                            Logger.info(`[Agent Execute]    模块名: ${testModuleName}`);
                            
                            // 构建测试目标名（首字母大写）
                            const testTargetName = testFileBaseName.split('_')
                                .map(word => word.charAt(0).toUpperCase() + word.slice(1))
                                .join('') + 'Test';
                            
                            Logger.info(`[Agent Execute]    目标名: ${testTargetName}`);
                            
                            const testSubDir = path.dirname(testDir); // src 的父目录
                            
                            gnContent = GNFileManager.generateSubmoduleBuildGN(
                                testModuleName,
                                testTargetName,
                                testFileName,
                                sourceGNConfig,
                                testSubDir,
                                sourceDir,
                                {
                                    importPath: '../../../../../distributedaudio.gni', // 可以根据项目动态计算
                                    subsystemName: 'distributed_audio',
                                    partName: 'distributed_audio'
                                }
                            );
                            
                            fs.writeFileSync(testBuildGnPath, gnContent, 'utf8');
                            Logger.info(`[Agent Execute] ✅ 子模块 GN 文件已创建: ${testBuildGnPath}`);

                            // 确保父级存在 group("unittest") 并注册当前子模块目标
                            const parentDir = path.dirname(path.dirname(testBuildGnPath)); // unittest 的父目录
                            const parentGroup = UTBuildGNUpdater.ensureParentGroupBuildGN(parentDir);
                            if (parentGroup) {
                                const relFromParent = `./${path.basename(path.dirname(testBuildGnPath))}`; // ./unittest
                                const regOk = UTBuildGNUpdater.registerToGroup(parentGroup, relFromParent, `${testModuleName}_test`);
                                Logger.info(`[Agent Execute] ${regOk ? '✅' : '⚠️'} 父级 group 注册 ${regOk ? '成功' : '失败'}`);
                            }
                            
                            this.sendMessage({
                                type: 'info',
                                level: 'success',
                                message: `✅ 已**新建**子模块 GN 文件: \`${testGnRelativePath}\`\n` +
                                        `   ✓ 子模块: ${testModuleName}\n` +
                                        `   ✓ 包含 config、ohos_unittest 和 group`
                            });
                            
                            // === 在父级 group 中注册子模块 ===
                            if (parentGroupGnPath) {
                                Logger.info(`[Agent Execute] 📝 注册子模块到父级 group`);
                                
                                // 自动推断依赖路径（从现有 deps 中分析路径模式）
                                const registerResult = GNFileManager.registerSubmoduleToParentGroup(
                                    parentGroupGnPath,
                                    testModuleName
                                    // depPath 不传，让方法自动推断
                                );
                                
                                if (registerResult.success) {
                                    this.sendMessage({
                                        type: 'info',
                                        level: 'success',
                                        message: `✅ 已在父级 group 中注册子模块: \`${testModuleName}\``
                                    });
                                } else {
                                    this.sendMessage({
                                        type: 'info',
                                        level: 'warning',
                                        message: `⚠️ 注册子模块失败: ${registerResult.message}\n   请手动添加到 deps`
                                    });
                                }
                            }
                        } else {
                            // === 平铺结构：生成标准的 BUILD.gn ===
                            Logger.info(`[Agent Execute] 🔨 生成标准 BUILD.gn (平铺结构)`);
                            
                            const testTargetName = path.basename(testDir) + '_test';
                            
                            gnContent = GNFileManager.generateTestBuildGN(
                                testTargetName,
                                testFileName,
                                sourceGNConfig,
                                testDir,
                                sourceDir,
                                sourceBuildGn || undefined,  // 传入源 BUILD.gn 路径，用于路径转换
                                document.uri.fsPath          // 被测实现源码路径
                            );
                            
                            fs.writeFileSync(testBuildGnPath, gnContent, 'utf8');
                            Logger.info(`[Agent Execute] ✅ GN 文件已创建: ${testBuildGnPath}`);

                            // 确保父级存在 group("unittest") 并注册当前测试目标
                            const parentDir = path.dirname(testBuildGnPath); // 当前 BUILD.gn 所在目录的父级为 test/
                            const parentGroup = UTBuildGNUpdater.ensureParentGroupBuildGN(path.dirname(parentDir));
                            if (parentGroup) {
                                const relFromParent = `./${path.basename(parentDir)}`; // 例如 ./unittest
                                const regOk = UTBuildGNUpdater.registerToGroup(parentGroup, relFromParent, testTargetName);
                                Logger.info(`[Agent Execute] ${regOk ? '✅' : '⚠️'} 父级 group 注册 ${regOk ? '成功' : '失败'}`);
                            }
                            
                            this.sendMessage({
                                type: 'info',
                                level: 'success',
                                message: `✅ 已**新建** GN 文件: \`${testGnRelativePath}\`\n` +
                                        `   ${sourceGNConfig ? '✓ 包含源文件的完整配置 (deps, includes 等)' : '✓ 使用基本模板'}`
                            });
                        }
                    }
                }
                
                // 3. 打开测试文件
                const doc = await vscode.workspace.openTextDocument(testFilePath);
                await vscode.window.showTextDocument(doc);
                Logger.info(`[Agent Execute] ✅ 已打开测试文件`);
                
            } catch (error) {
                Logger.error(`[Agent Execute] ❌ 创建文件失败: ${error}`);
                this.sendMessage({
                    type: 'error',
                    message: `创建文件失败: ${error}`
                });
            }
        } else {
            // 手动确认模式：显示采纳/拒绝按钮
            this.sendMessage({
                type: 'info',
                level: 'success',
                message: '✅ 步骤 6/6: 测试代码生成完成！\n\n请检查以下文件的修改：'
            });

            // 发送测试文件的操作请求
            this.sendMessage({
                type: 'file-action',
                actionId: `test-file-${Date.now()}`,
                fileType: 'test',
                filePath: testFilePath,
                displayPath: testRelativePath,
                content: fullTestCode,
                action: require('fs').existsSync(testFilePath) ? 'modify' : 'create'
            });

            // 如果有 GN 文件，生成并发送 GN 文件的操作请求
            if (testBuildGnPath && testGnRelativePath) {
                try {
                    const fs = require('fs');
                    let gnContent: string;
                    const testFileName = path.basename(testFilePath);
                    const testDir = path.dirname(testFilePath);
                    const sourceDir = path.dirname(document.uri.fsPath);
                    
                    if (fs.existsSync(testBuildGnPath)) {
                        // GN 文件已存在，生成添加测试文件的修改内容
                        Logger.info(`[Agent Execute] 📝 GN 文件已存在，准备添加测试文件`);
                        const result = GNFileManager.addTestFile(testBuildGnPath, testFileName);
                        if (result.success) {
                            gnContent = result.newContent;
                        } else {
                            Logger.warn(`[Agent Execute] ⚠️ 生成 GN 修改内容失败: ${result.message}`);
                            gnContent = fs.readFileSync(testBuildGnPath, 'utf8');  // 使用原始内容
                        }
                    } else {
                        // GN 文件不存在，生成新的 GN 文件内容
                        Logger.info(`[Agent Execute] 📝 GN 文件不存在，准备生成新的 GN 文件`);
                        Logger.info(`[Agent Execute]    是否分层结构: ${needsSubdirectory ? '是' : '否'}`);
                        
                        // 从 ProjectAnalyzer 的结果中提取源文件的 GN 配置
                        let sourceGNConfig = null;
                        if (sourceFileInfo && sourceFileInfo.sourceBuildGN && sourceFileInfo.sourceBuildGN.targets.length > 0) {
                            // 找到包含当前源文件的 target
                            const sourceFileName = path.basename(document.uri.fsPath);
                            const normalizedFilePath = path.normalize(document.uri.fsPath).toLowerCase().replace(/\\/g, '/');
                            
                            let matchedTarget = null;
                            for (const target of sourceFileInfo.sourceBuildGN.targets) {
                                for (const source of target.sources) {
                                    const normalizedSource = path.normalize(source).toLowerCase().replace(/\\/g, '/');
                                    if (normalizedSource === normalizedFilePath || path.basename(source) === sourceFileName) {
                                        matchedTarget = target;
                                        break;
                                    }
                                }
                                if (matchedTarget) break;
                            }
                            
                            if (matchedTarget) {
                                sourceGNConfig = {
                                    deps: matchedTarget.deps || [],
                                    include_dirs: matchedTarget.include_dirs || [],
                                    external_deps: matchedTarget.external_deps || [],
                                    cflags_cc: [],
                                    configs: matchedTarget.configs || [],
                                    public_configs: [],
                                    defines: matchedTarget.defines || [],
                                    module_out_path: '',
                                    part_name: '',
                                    subsystem_name: ''
                                };
                                Logger.info(`[Agent Execute] ✅ 已提取源文件 GN 配置 (目标: ${matchedTarget.name})`);
                            }
                        }
                        
                        if (needsSubdirectory && testModuleName) {
                            // 分层结构：生成子模块 BUILD.gn
                            Logger.info(`[Agent Execute] 🔨 生成子模块 BUILD.gn 内容 (分层结构)`);
                            
                            const testTargetName = testFileBaseName.split('_')
                                .map(word => word.charAt(0).toUpperCase() + word.slice(1))
                                .join('') + 'Test';
                            
                            const testSubDir = path.dirname(testDir); // src 的父目录
                            
                            gnContent = GNFileManager.generateSubmoduleBuildGN(
                                testModuleName,
                                testTargetName,
                                testFileName,
                                sourceGNConfig,
                                testSubDir,
                                sourceDir,
                                {
                                    importPath: '../../../../../distributedaudio.gni',
                                    subsystemName: 'distributed_audio',
                                    partName: 'distributed_audio'
                                }
                            );
                        } else {
                            // 平铺结构：生成标准 BUILD.gn
                            Logger.info(`[Agent Execute] 🔨 生成标准 BUILD.gn 内容 (平铺结构)`);
                            
                            const testTargetName = path.basename(testDir) + '_test';
                            gnContent = GNFileManager.generateTestBuildGN(
                                testTargetName,
                                testFileName,
                                sourceGNConfig,
                                testDir,
                                sourceDir,
                                sourceBuildGn || undefined,
                                document.uri.fsPath
                            );
                        }
                    }
                    
                    // 发送 GN 文件操作请求（包含内容）
                    this.sendMessage({
                        type: 'file-action',
                        actionId: `gn-file-${Date.now()}`,
                        fileType: 'gn',
                        filePath: testBuildGnPath,
                        displayPath: testGnRelativePath,
                        content: gnContent,  // 添加 GN 文件内容
                        action: fs.existsSync(testBuildGnPath) ? 'modify' : 'create'
                    });
                } catch (error) {
                    Logger.error(`[Agent Execute] ❌ 生成 GN 文件内容失败: ${error}`);
                    // 即使生成失败，也发送不带内容的请求，让用户知道需要手动处理
                    this.sendMessage({
                        type: 'file-action',
                        actionId: `gn-file-${Date.now()}`,
                        fileType: 'gn',
                        filePath: testBuildGnPath,
                        displayPath: testGnRelativePath,
                        action: require('fs').existsSync(testBuildGnPath) ? 'modify' : 'create'
                    });
                }
            }
        }

        // 保存生成的代码到对话历史和内部状态
        this.lastGeneratedCode = fullTestCode;
        this.conversationHistory.push({
            role: 'assistant' as const,
            content: `已生成测试代码:\n\`\`\`cpp\n${fullTestCode}\n\`\`\``
        });
        
        // === 新增：覆盖率分析 ===
        try {
            Logger.info(`[Agent Execute] 📊 开始分析覆盖率...`);
            
            // 获取源代码：如果有选中文本则使用选中部分，否则使用整个文件
            const fullSourceCode = selectedText || document.getText();
            const sourceFilePath = document.uri.fsPath;
            const displayName = selectedText ? '选中代码段' : path.basename(sourceFilePath);
            
            Logger.info(`[Agent Execute]    分析范围: ${displayName} (${fullSourceCode.length} 字符)`);
            
            // 使用选中的源代码进行分析
            const coverageReport = await CoverageAnalyzer.analyzeFileCoverage(
                fullSourceCode,
                displayName,
                fullTestCode,
                sourceFilePath
            );
            
            // 只有在有实际数据时才发送报告
            if (coverageReport.totalLines > 0 || coverageReport.testCases.length > 0) {
                const reportMarkdown = CoverageAnalyzer.formatCoverageReport(coverageReport);
                
                this.sendMessage({
                    type: 'info',
                    level: 'info',
                    message: reportMarkdown
                });
                
                Logger.info(`[Agent Execute] ✅ 覆盖率分析完成: 行覆盖 ${coverageReport.lineCoverage.toFixed(1)}%, 分支覆盖 ${coverageReport.branchCoverage.toFixed(1)}%`);
            } else {
                Logger.warn(`[Agent Execute] ⚠️ 覆盖率分析未检测到有效数据，跳过报告`);
            }
            
        } catch (error) {
            Logger.warn(`[Agent Execute] ⚠️ 覆盖率分析失败: ${error}`);
            // 覆盖率分析失败不影响主流程，只记录警告
        }
        
        // 发送生成完成提示
        this.sendMessage({
            type: 'info',
            level: 'success',
            message: '✅ **UT生成完成！**\n\n' +
                    '📝 测试文件已追加到: `' + path.basename(testFilePath) + '`\n' +
                    '📦 BUILD.gn已更新: `' + path.basename(sourceBuildGn || '') + '`\n\n' +
                    '💡 **下一步：**\n' +
                    '   • 使用 `git diff` 查看新增的测试用例\n' +
                    '   • 根据实际情况修改测试逻辑\n' +
                    '   • 运行测试验证功能\n\n' +
                    '🔄 若需生成更多测试，请选择其他函数重新执行'
        });
        
        Logger.info(`[Agent Execute] ✅ 已保存对话上下文，支持后续优化`);

        return {
            testCode: fullTestCode,
            testFilePath,
            gnChanges: {
                sourceBuildGn,
                testBuildGn: testBuildGnPath
            }
        };
    }

    /**
     * 处理用户的后续对话消息（优化/调整测试代码）
     */
    async handleChatMessage(userMessage: string): Promise<string> {
        if (!this.currentDocument) {
            throw new Error('没有可用的上下文，请重新生成测试');
        }

        Logger.info(`[Agent Mode] 处理用户对话: ${userMessage}`);

        // 构建上下文提示（让LLM了解当前状态，但不强制要求生成代码）
        const contextPrompt = `
当前上下文：
- 我们刚刚为一个C++文件生成了单元测试代码
- 当前的测试代码如下：
\`\`\`cpp
${this.lastGeneratedCode}
\`\`\`

用户的消息是：
"${userMessage}"

请根据用户的意图回应：
1. 如果用户要求修改/优化测试代码，请生成完整的新代码（保持OpenHarmony规范）
2. 如果用户在询问问题，请直接回答问题
3. 如果用户在讨论其他话题，请正常对话
`;

        // 添加上下文和用户消息到对话历史
        this.conversationHistory.push({
            role: 'user' as const,
            content: contextPrompt
        });

        // 流式生成AI回复
        let aiResponse = '';
        // 智能选择最适合的模型
        const { ModelSelector } = await import('../../../../core/llm/modelSelector');
        const selectedModel = ModelSelector.selectModel('unitTest');
        
        let llm = this.llmFactory.getLLM(selectedModel);
        
        if (!llm) {
            // 尝试备用模型
            const fallbackModels = ModelSelector.getFallbackModels('unitTest');
            for (const fallbackModel of fallbackModels) {
                llm = this.llmFactory.getLLM(fallbackModel);
                if (llm) break;
            }
            
            if (!llm) {
                throw new Error('无法获取 LLM 实例（所有备用模型均不可用）');
            }
        }

        try {
            this.sendMessage({
                type: 'info',
                level: 'info',
                message: '💭 正在思考...'
            });

            this.currentAbortController = new AbortController();
            const stream = llm._streamChat(this.conversationHistory, this.currentAbortController.signal);

            for await (const chunk of stream) {
                // 检查是否被取消
                if (this.currentAbortController?.signal.aborted) {
                    Logger.info('[handleChatMessage] 检测到取消信号，停止生成');
                    throw new Error('用户取消操作');
                }
                
                if (chunk.content && typeof chunk.content === 'string') {
                    aiResponse += chunk.content;
                    // 流式输出（不强制为代码块，让前端根据内容渲染）
                    this.sendMessage({
                        type: 'code-chunk', // 使用已存在的类型
                        content: chunk.content
                    });
                }
            }

            // 添加到对话历史
            this.conversationHistory.push({
                role: 'assistant' as const,
                content: aiResponse
            });

            // 检测回复中是否包含代码块（简单判断）
            const codeBlockRegex = /```(?:cpp|c\+\+)?\s*([\s\S]*?)```/;
            const codeMatch = aiResponse.match(codeBlockRegex);
            
            if (codeMatch && codeMatch[1]) {
                // 如果包含代码块，更新测试代码
                const extractedCode = codeMatch[1].trim();
                this.currentTestCode = extractedCode;
                this.lastGeneratedCode = extractedCode;
                
                this.sendMessage({
                    type: 'info',
                    level: 'success',
                    message: '✅ 测试代码已更新！可以继续对话或提出新的问题。'
                });
                
                Logger.info(`[Agent Mode] ✅ 测试代码已更新，长度: ${extractedCode.length}`);
            } else {
                // 纯文本回复，不更新代码
                this.sendMessage({
                    type: 'info',
                    level: 'success',
                    message: '💬 回复完成！有其他问题随时问我。'
                });
                
                Logger.info(`[Agent Mode] ✅ 对话回复完成（未更新代码）`);
            }

            return aiResponse;
        } catch (error) {
            Logger.error(`[Agent Mode] 处理对话消息失败: ${error}`);
            this.sendMessage({
                type: 'info',
                level: 'warning',
                message: `❌ 优化失败: ${error}`
            });
            throw error;
        }
    }

    /**
     * 获取当前生成的测试代码
     */
    getCurrentTestCode(): string {
        return this.currentTestCode;
    }
}

